Slurpee.txt
11/20/94

Slurpee 1.3
transfers paragraphs or tab-delimited text
between a text file and Newton soup entries
via a terminal emulator and serial connection

see Slurpee.1st for other info.


==========
Why?

I wanted a convenient way to move information from the desktop to soups on the
Newton, especially text paragraphs to separate Notepad entries, and vice
versa.  Newton Connection Kit (NCK) is also a possibility, though it is
slower, more complicated, and expensive.  Although Slurpee was created
primarily to support moving NewtonScript application/method sources and
graphic/sound resources by users of my Newt application development tool, I
thought that this utility may be useful for others as well.

Slurpee is not a package downloader -- though perhaps someday...


==========
Slurpee and Slurp and SuperSlurp -- Introduction and Differences

Slurpee was based initially on the Apple DTS "Slurp" example.  It has since
evolved to include custom extensions (see Revision History) such as transfer
from Newton to desktop (DUMP), xfer of text Notes, ERASE, faster MNP xfers
(like SuperSlurp), and xfers of bitmap and sound resource strings.

The original Slurp documentation and examples are included as SlurpOld.txt and
CasioNam.tab, which are Copyright 1993, 1994 Apple Computer; these and the
Slurp and/or SuperSlurp NTK project source files can be obtained from
AppleLink, ftp.apple.com/dts/newton and the Newton Developer CD.

Slurpee 1.3 is shareware ($10) -- see Shareware note later; versions earlier
than 1.3 were freeware.  Slurpee may be freely distributed via online
services and bulletin boards if it is unmodified and includes this and other
files mentioned here.  It may not be commercially bundled or redistributed on
CD-ROM, floppy disk, PCMCIA, networks or other media without permission.

Slurpee is currently free to registered users of "Newt".  Newt is a shareware
native Newton application development environment, i.e., you can build
applications in NewtonScript directly on your Newton.  In particular, I
distribute Newt source for Slurpee if you would like to customize your own
version or understand how it works. More info at end of this file.

The original Slurp was one-way: it transmitted lines in a desktop
tab-delimited text file sent over a serial connection into Newton soup
entries. Slurpee is two-way: it can also send Newton soup entries as a
tab-delimited text file to a terminal emulator program. Slurpee also works
both ways in converting between multiline text paragraphs and entries in the
Notes soup.  I've fixed a few Slurp problems with disconnecting cleanly.  I
also added a "para" datatype that's useful for adding a note to a Names
entry, a general "class:string" datatype, and binary datatypes for bitmap,
sound and code resources.

Slurpee resembles the original minimalist Slurp interface with a few changes:
the title, some additional status messages (and others removed), draggable,
and speed and sleep controls.  What's transferred and in which format is
controlled on the desktop side. For example, to send data to your Newton, you
tell Slurpee to Receive, and then send text containing soup name, format
specification, and data, via your terminal emulator, usually as a file.  To
send data from your Newton, you also set Slurpee to Receive; however, the
text file you send contains a soup name and format specification, but no data
-- just a Dump command (this assumes you set up a log file to capture the
data returned).  Directions on how to setup Slurp/Slurpee with a terminal
emulator can be found in the original SlurpOld.txt and later in this file.

Slurpee 1.3 starts the connection automatically, and does not disconnect
automatically -- in other words, you never need to tap "Receive" unless
you've tapped "Disconnect" (or changed speeds).  If you experience an error,
you may need to Disconnect and then tap Receive to reset the connection;
restarting your Newton is occasionally necessary. Slurpee starts waiting for
input immediately; after receiving each file, it beeps and waits for the
next. Note: if you have many (or long) transfers, you may wish to set the No
Sleep checkbox which temporarily modifies your Preferences:Sleep setting so
that your Newton does not go to sleep during a long transfer and lose data.


==========
WARNING

Since Slurpee can add or remove entries from your soups, please keep your
information backed up regularly, and follow the formats and commands
carefully.

Slurpee makes no claims to being a user-friendly tool.  The process of
configuring your terminal emulator and defining frame specifications may
yield strange errors.  I can provide some documentation, examples and
interactive help, but you'll have the most success if you have used terminal
emulators, have a little programming or database background, and are
adventurous and not easily frustrated.  Once you've surpassed the initial
hurdles (much easier than installing and configuring Windows :) ), Slurpee
can be quite useful for quickly and flexibly moving information in and out of
your Newton.


==========
Getting Started

- Download Slurpee to your Newton via Newton Connection Kit
  or a package downloader utility.

- Serial cable (still) connected to the Newton, with no other open serial
  connections on the desktop side (e.g., NTK inspector), or any other
  current use of comms on the Newton (e.g., beaming).

- Open a communications program (e.g., terminal emulator) on your desktop
  system, with the following configuration:
    Serial Tool, 9600 baud, 8 data bits, 1 stop bit, XON/XOFF handshaking
  (get it working at 9600 before attempting 56K with MNP)

  - For file transfer, specify the Text Tool (not XMODEM or other protocols)

  - If the comm program has transmit delays between chars or lines, you
  may wish to set these to 0.

- Open Slurpee on the Newton; it automatically starts in Receive mode.
  Or, if you have tapped Disconnect, then tap Receive.

- You may have to do an "Open Connection" in your terminal emulator

- to check that the connection is working, just type "xx".  You should see
  a message like "not a soupname: xx"

- another simple thing to try before attempting anything more complicated
  is to type:

  Notes
  {}
  hello there
  -----
  BYE!

if you exit Slurpee, the note should be in your Notepad (Unfiled).

- On the Mac/PC, choose "Send File..." or "Send Text..." in the comm
  program, and choose the file to be sent, e.g., CasioNam.tab.  If you are
  doing a "Dump", immediately setup a file to log/receive/capture the result.
  Slurpee will display the number of entries received/dumped in a view near
  the top of the screen.  When the file transfer is complete, Slurpee will
  automatically wait for another transfer. I would suggest starting with the
  CasioNam.tab example first (you could delete some of the lines, but don't
  start making other modifications just yet...)
  
- Tap Disconnect to end the connection, or just close Slurpee.


==========
Slurpee Format

The general format of a Slurpee interaction:

  soupname             e.g., Names
  frame specification  e.g., see SlurpOld.txt, CasioNam.tab
  optional erase       e.g., ERASE!
  data                 tab-delimited lines or just text
  data
  ...
  BYE!                 note: DUMP! also does BYE!

If the soupname does not exist, subsequent lines are ignored.
you can create a new soup (see Creating Soups and Indexes)

Each data entry occurs on a separate line (see \ line continuation
discussed under bitmap; also Notes are delimited by special ----- line).
For tab-delimited entries, blank lines are ignored.

New data entries are stored in the default store, e.g., on your memory card if
"Store new items on card" is checked.  When exporting entries (i.e., DUMP),
entries are taken from all stores, i.e., internal memory and any card(s).
[note: this is a "union" soup]


==========
Slurpee Uses

Here is a summary of the four kinds of basic transfer supported by Slurpee:
      direction                         soup
----------------------      -------------------------
from desktop to Newton      1. any soup      2. Notes
from Newton to desktop      3. any soup      4. Notes


=====
1. data to Newton ("Slurp classic")

A tab-delimited text line corresponds to a data (soup) entry.

See CasioNam.tab

For Names, I've found that a phones field is required, otherwise the entries
will generate errors later when you browse them.  At a minimum, you need
something like phones: ["workPhone"] in your framespec, then an extra tab in
your data entries to reflect an empty field.

Design Note: Slurpee (like Slurp and SuperSlurp) assumes that are no more than
approximately 20 fields embedded in one frame (you could have more than 20
fields per line if you have nested frames); the order of values in a line
should correspond to the order of slots in the frame spec. For small (<20)
number of slots, the frame spec maintains a linear order when it is compiled;
however, for larger number of slots this ordering is not preserved. If this
is a problem for any registered users, it will be fixed...

If you'd like to add a text note to a Names entry (the text field you see when
you Show:Card&Notes), include notes: ["para"] in the frame spec. In the data
entries, the text in this position up to the next tab (or end of line if it's
last) will be included as a single paragraph in the note field.

Version 1.1 added support for "class:string" type for entrySpec so you can embed
'class' information for strings directly with the value. For a phone entry,
you could specify "homePhone:555 1234" for input; you would also get this
format if you DUMP!

Although a soup is like a database and may have an index that treats a
particular slot as a "primary key", Slurpee does no checking to eliminate
"duplicates". If you want to remove earlier items, do an ERASE! of a soup (or
folder); or, you can remove individual entries via a soup utility like
StewPot.

=====
2. text to Newton ("Slurp for Notes")

  Notes
  {labels: 'Business, viewFont: <fontspec>, height: <num>}**
  text
  more text
  -----         paragraph delimiter (at least 5 dashes)
  more lines
  -----
  BYE!

**the frame specification for data is more of a template with type information;
for Notes, it is used to provide default values.  For labels, the value is a
symbol corresponding to a folder destination, e.g., 'Personal, 'Business, or
nil or 'nil (for Unfiled).

If viewFont is not specified, then the Note (for the Notepad) is created with
the current default font set by the user in Styles. If viewFont is specified,
it should be a font specification, e.g., a coded integer like 10241
(userFont10) or font description like {family: 'espy, face: 0, size: 9} -- see
Newt or NTK documentation.  I have included viewFont: 10241 in the .nwt files
to be consistent with Newt's default.

If height is not specified, then Slurpee creates each Notepad entry with its
calculated height (in version 1.0, each had a fixed height of 265 -- which was
too large for some paragraphs, too short for others).  You can specify a fixed
height, e.g., {labels: 'Personal, height: 100}. If the Notepad clips a long
para, hold down on the note separator bar in the NotePad for several seconds,
then drag it downwards (it disappears) & then let go -- the separator should
jump to the end.

Note: if you include a symbol for labels slot that does not (yet) exist, be sure
to do Edit Folders later on your Newton to add it -- otherwise, the only
way you'll see these entries is via All Notes.

examples:

  {labels: 'Business, viewFont: 10241} // what Newt normally uses
  {labels: 'Personal} // uses current default font (Styles)
  {labels: nil, viewFont: {family: 'espy, face: 0, size: 9}, height: 500}
  {} // Unfiled folder with default font and calculated height
  {labels: nil}  // same as {}
  {labels: 'nil} // same as {}


Erase command: if you know what you are doing (and have backed things up
first), you can insert an ERASE! command as the third line for both
tab-delimited (#1) and text (#2) transfers.  This erases all entries from the
specified soup, or if you've specified labels in your frame spec (for Names
or Notes), it erases just the entries in that folder; if a field has labels,
you can specify the symbol _all to erase entries in all folders, e.g.,
{labels: '_all}.  ERASE can be handy especially if want to get rid of many
existing entries before adding new information. Warning: this does not give
you a dialog box asking to Confirm erasing of entries!!!  For example, if you
edited Newt sources for your project on the desktop, and wanted to replace
these completely on your Newton, you could do something like:

  Notes
  {labels: 'Programming, viewFont: 10241}
  ERASE!
  myApp
  {_proto: 'protoApp,
  ...
  -----
  myApp+aButton
  {_proto: 'protoTextButton,
  ....
  -----
  BYE!


=====
3. data to desktop ("Slurp in reverse")

  soupname
  framespec  (see CasioNam.dmp)
  DUMP!

same powerful frame specification as in #1. entries are written to terminal
emulator as tab-delimited lines in frame specification order. (If possible,
you should have your terminal emulator preserve tabs, wrap lines (rather than
overwrite characters), and save/capture to a log file).  To have Slurpee
pause so that you can set up a log/capture file after sending this, include
the number of seconds followed by a semi-colon, e.g., DUMP!10; .  Any data
fields with text values that contain newlines will be transmitted as is (you
may need to re-edit results into a true tab-delimited text format).

=====
4. text to desktop ("Slurp for Notes, in reverse")

  Notes
  frame specification, e.g., {labels: 'Business}**
  DUMP!

**this is used as a filter to copy entries from only that folder. it copies
all text data entries from each Note (if it is non-empty text) as a
paragraph. for example, see Business.dmp. entries are written as multi-line
entries separated by -----.  see 3 for description of optional pause.  for a
frame spec that includes labels, you can specify _all (as with ERASE) to
indicate entries in all folders, e.g., {labels: '_all}


==========
Terminal Emulators We Have Known and Loved

Given the wide variety of terminal emulators that are available on Mac,
Windows, Unix and other platforms, I hope that the guidelines below (and also
in SlurpOld.txt), are adequate, and that with a little interpretation and
experimentation, you will be running soon without excess pain and suffering.
Please send me email (addresses at end) to let me know which software you are
using and whether there was anything unusual you needed to do to get Slurpee
to work (or if there's a comms package that did not work well or at all) --
I'll summarize these in future release notes and make available to other
users who have similar software or setups.

For example, I've tried:
Macintosh
- FreeTerm 3.01
  handles long lines and files well
  few amenities; no MNP (56K) support
- ZTerm 1.03b
  quite reliable, but appears to truncate long lines (>~4K)
  no support for MNP
- MacTerminal 3.0
  appears to truncate long lines (>~4K) and some "long files"
  not useful for DUMP: no text capture facility & overwrites chars
  both MNP and 9600 supported

Windows
- Reflections xxx
  this worked for me awhile ago (not tested recently/exhaustively)

others...


==========
Using Slurpee at 57.6K

If your terminal emulator supports MNP with software error connection, you may
be able to use Slurpee to transfer at 57600 instead of 9600. Currently, this
works on the Mac with MacTerminal and ClarisWorks if you have the Apple Modem
Tool.  I would be interested in hearing of other successful configurations
on other platforms and with other emulators.

[excerpted from "SuperSlurp.README"]:
"
1. Need a mac with the Apple Modem Tool in your extensions folder.
   This is the CTB (Communications ToolBox) tool which comes with NTK. 
2. The basic settings are: Newton Serial Connection, 57600 bps, Software error
   correction; file transfer using TEXT tool, CR at line endings. You can use
   MacTerminal, ClarisWorks, or some other terminal emulator of your choice,
   or even your own Mac or PC code if it supports MNP level 5.
3. On the macterminal side, choose "Wait for Connection" 
4. On the Newton side, open SuperSlurp and hit the "Receive" button 
5. On the macterminal side, send the "Names Data" file using the TEXT
   tool, CR at line endings 
6. The Newton will automatically suck down the data, using MNP to regulate
   the data flow (you can watch this process easily with the progress bar
   in MacTerminal or ClarisWorks)."

Slurpee Note: Since Slurpee automatically starts the connection at 9600, when
you select 57600. This automatically Disconnects.  Then, select Wait for
Connection in your appropriately configured desktop terminal emulator, then
tap Receive in Slurpee. Test first with smaller files (I have noticed some
intermittent problems with the connection getting dropped when sending VERY
large files).  To reduce overhead, less status information is displayed less
frequently.


==========
Creating Soups and Indexes

The first line of a transaction is a soup name.  In the default situation,
if this name does not exist, Slurpee ignores it and subsequent lines until
it finds a valid soup name.

You can create new soups and indexes.  Before doing this, you should feel
comfortable with transferring entries into existing soups and customizing an
entry spec.  I would also recommend obtaining a good soup utility (StewPot
works pretty well) so that you can inspect entries, remove entries and remove
soups.

To create a soup, follow the name with a ! followed by an array of index
specifications, e.g., [] is none.  The soup is created as a "union" soup that
appears in each store, i.e., internal memory and each card.

  TestSoup![]
  {a: "int", b: "string"}
  0	hello
  1	there
  BYE!


Here is an example of a different soupname line if you had wanted to index
on the integer field:
  TestSoup![{structure: 'slot, path: 'a, type: 'int},]


Indexes can be useful to applications for random access or for accessing soup
entries in a particular sort order. For examples of other index specs see the
NTK docs, or the bitmap and sound examples (next); more docs to follow... 
Also, see earlier note about duplicate entries.


==========
Transferring Bitmaps

You can transfer bitmap, PICT and sound resources to the Newton, for example,
to include in an application you are building with Newt.  Small bitmaps can
be created by hand if you are patient and not binary challenged; a tool like
ResEdit on the Mac works pretty well to extract hex strings.  Let me know
which other tools on Mac or other platforms you find useful so I can share
this info.

For example, the following example creates 3 identical entries for an "i"
graphic that can go in an info button.

  ClipArt![{structure: 'slot, path: 'name, type: 'symbol},] // index on name slot. for use with infobutt.nwt example file
  {name: 'symbol, width: "int", bitmap: "bitmap"}
  info icon	5	700000007000000000000000F000000070000000700000007000000070000000F8000000
  info icon2	5	7000000070000000000\
  00000F00000007\
  0000000700000007000000070000000F8000000
  info icon3	5	!\
  70000000\
  70000000\
  00000000\
  F0000000\
  70000000\
  70000000\
  70000000\
  70000000\
  F8000000
  BYE!


The first line is the name of the soup -- ClipArt.  Since ! occurs, Slurpee
creates the soup if it doesn't already exist. It also provides an expression
that is compiled to create an array of indexes -- it must be at least [].  In
this example, we want the name slot (first column) to be indexed for direct
lookup/faster retrieval by some application.

The second line is the entry description.  Here, name is a string which is
converted to a symbol; width indicates actual width of the bitmap in pixels
(for storage/transfer purposes, this is "rounded up" to 32 pixel increments);
bitmap indicates a new datatype which converts the ascii string into a binary
unicode format (because of memory limitations for large bitmaps, this field
must occur last).  Note: height is not supplied -- the number of rows is
computed from the bitmap.

The third line is an actual entry, with fields delimited by tabs. info icon is
the name (including the space in this case; however, it's generally a good
idea to use only alphanumeric and _ in symbols). width is 5, the bitmap
occupies the remainder of the (long) line.

==========
Line Continuations

Before interpreting the bitmap, let's look at two other variations. Depending
on the length of the bitmap entry, and the capabilities/limits of your text
editor and terminal emulator, you may want lines that are no longer than 72,
80 characters or some other value.  The next line that creates "info icon2"
actually consists of 3 lines of text.  This line and the next are suffixed
with \ which is a line continuation character. Slurpee concatenates these
three lines together as text before processing it to produce an identical
result as the first line. This form of line continuation can be used with any
tab-delimited text line. (When splitting a line with \, make sure your text
editor doesn't auto-indent and add extra tabs to subsequent lines).  As
Slurpee reads a continuation line, it provides feedback on the current status
of the "entry len".  Of course, the final line of an entry should not end in \. 

For bitmap or sound lines that are especially long, e.g., > 4K, I would
recommend another technique, illustrated by "info icon3". If the first line
ends with !\, then the subsequent hex data is converted immediately before
concatenation into a binary (rather than a normal) string. This allows much
larger resources to be transferred. NOTE: number of hex characters on a line
MUST be even.  (Check with your text editor's "Cursor position" command).
Slurpee provides feedback on the current status of the "binary len".

Some approximate (current) limits on these three methods:
  <31K on a single line (but some terminal emulators truncate after 4K)
  <25K on multiple lines (as text) [concatenation overhead, heap limits]
  >63K on multiple lines (binary) [haven't tested any larger yet, though
  this is close to the practical limit of what you can keep in heap or
  store in a soup]


==========
Back to Bitmaps

Here's how to interpret the bitmap string.  Each hexadecimal character of the
bitmap string represents 4 bits; each row is represented by a multiple of 8
characters (32 bits). In the info icon example, the width is 5, so each row has 8 characters
(even though 27 bits in each row are unused; if width is betwen 33 and 64,
you would need 64 bits, or 16 characters for each row, and so on). for
clarity, "info icon3" was broken into rows of 8 characters each -- here it is
expanded with a binary annotation (omitting trailing zeros):

  70000000 // 0111 00...
  70000000 // 0111 00...
  00000000 // 0000 00...
  F0000000 // 1111 00...
  70000000 // 0111 00...
  70000000 // 0111 00..
  70000000 // 0111 00...
  70000000 // 0111 00...
  F8000000 // 1111 10...

With some squinting (or filling in squares on graph paper), this should
look suspiciously like an "i". Slurpee translates this to a soup entry
as follows:
  {name: |info icon|, // vertical bars necessary here to embed the space
  width: 5,
  bitmap: {bounds: {left: 0, top: 0, right: 5, bottom: 9}
           bits: <bits>}
   }

Later, you could create a picture button, in Newt for example, to use this
bitmap as an icon (GetPICTasBits is defined in libproto.nwt):

  {_proto: 'protoPictureButton,
  ...
  icon: :GetPICTasBits("info icon", "ClipArt"),
  }

How would you create these bitmaps? In addition to creating by hand or using
some of the examples that come with Newt, you can use the icon editor in
ResEdit (on a Mac), open the hexadecimal editor template, do a select all and
copy (or copy it in segments if > 32K), then paste into a text editor. This
hex encoding is ~2x the original resource size and ~2x the final soup size.
Or, on the Newton, you can copy bitmap entries (using Newt) from ROM or
existing applications to a soup, and then DUMP! the entries to your desktop,
then copy/paste as text into your own .bit file.

You can transfer and create fairly large bitmaps -- largest I have used
so far is 230x230 for the dot2dot example.

If the name of a bitmap is suffixed with !, this is interpreted (as by NTK) as
a mask. When an icon is highlighted, its region inverts by default.  You can
specify a different mask via ! (this assumes that the regularly named bitmap
already exists, i.e., occurred on an earlier line).  This adds a mask field
to the existing bitmap soup entry (and does not increment the "entries
slurped" count). Here is an example (I've truncated the lines):

  [file: pictbuts.bit]
  ClipArt![{structure: 'slot, path: 'name, type: 'symbol},]
  {name: 'symbol, width: "int", bitmap: "bitmap"}
  alarm clock	24	0000000000000000000000000000000000000000000000...
  alarm clock!	24	0008000001004000000800000880800004000400020010...
  light bulb	17	03C000000FF000001C1C00003006000060030000600300...
  light bulb!	36	0000000000000000000020100000000000002030000000...
  plane	22	60000000580038002600C80011C10C000A42100004B41000050820...
  scales	24	0018000000180000001800000000000000180000007E00001F...
  BYE!


Exercise for the reader: Name those Bits

WhatIsThis	16	!\
08000000\
54000000\
AA000000\
AA000000\
95000000\
551C0000\
4BE20000\
40030000\
87050000\
8A810000\
80020000\
400C0000\
40300000\
20400000\
20800000\
20800000


==========
Transferring PICTs

Transferring a PICT is easier since you don't need to know the width.  Since
a PICT can also be used in a clPictureView's icon slot, you could store it in
the same soup with bitmaps.  Using Bitmap or PICT depends on which format is
available to you, and which is more compact. (I don't know the internal
format of a PICT).

  ClipArt![{structure: 'slot, path: 'name, type: 'symbol},]
  {name: 'symbol, bitmap: "picture"}
  lightNewt 	00C9000000000022001D1101A00082A0008E01000A0...
  BYE!


==========
Transferring Sounds

Sounds can also be transferred, though since even "short" sounds can be
rather large, you may run into xfer limits. You need to know whether the
sound was sampled at a 11KHz or 22KHz sampling rate, which is specified as a
real number 11013.2 or 22026.4, respectively.

  [file: heavymet.snd]
  Sounds![{structure: 'slot, path: 'name, type: 'symbol},] 
  {name: 'symbol, samplingRate: "real", sound: "sound"}
  sine	22026.4	F26C000000003FB0FFFFFFE3944F27243D6381...[~14K]
  BYE!

  [file: soundadv.snd]
  Sounds![{structure: 'slot, path: 'name, type: 'symbol},]
  {name: 'symbol, samplingRate: "real", sound: "sound"}
  Boing	11013.2	80808080808080808080808080808080808080...[~15K]
  BYE!

To use a sound on the Newton, from Newt, you could do:
  PlaySound(:GetSound("boing","Sounds"))

The largest sound I've transferred so far is the several-second "dadadada"
sound from the False Alarm example.  This began as a ~31K binary resource on
the Mac, extracted via several copy&pastes as ~63K of hex text, and converted
into a ~32K soup entry on the Newton.  I don't know the internal format of a
sound string. It currently represents an uncompressed sample.  If you send me
pointers to info on sound formats and tools, I'll be glad to propagate to
other users.

(the Newt example bitsound.nwt allows you to browse bitmaps and play sounds
-- both the built-in ROM frames and those in ClipArt and Sounds)

Slurpee has hooks for transferring code resources, but I don't have any way
of testing this currently (still waiting for a working version of IR Remote
from DTS).


==========
Final Note on Shareware

I distributed Slurpee initially as freeware.  Since I found myself spending
more time on extending and documenting it and answering questions, and since
it bears less-and-less resemblance internally to the free, semi-public Slurp
example, I decided to make it shareware.  Send me a $10 check (or cash) and
you can expect more support, documentation and new features and fixes.  Send
$35 instead and you'll also be registered for Newt (see Newt note at end). 
You can register for Slurpee (SLRP13.SIT) or Newt (NEWT24.SIT) on Compuserve
(see SWREG).


==========
Revision History

1.3 (11/20/94)
- see slurpee.1st

1.2 (10/15/94)
- allows xfer at 56K if MNP supported by terminal emulator (~6x speedup)
- creates new soups and indexes
- trims initial LF (for PC files)
- creates bitmap, sound and code objects from hex (0123456789ABCDEF) ascii
  strings [for example, it can successfully xfer and convert a 15K
  hexadecimal character string (on a single line, without running out of
  memory!) into a 230x230 bitmap object that can be used as an icon]
- conserves memory better
- fixes ERASE! (All)

1.1 (9/3/94)
  (General)
- replaces custom slurp sound with built-in "fun beep" (saves 12K)
- closes Extras drawer
- removes spaces after soup name
- ignores non-existing soup names
  (type something like "xxx" to see if connection is active)
- starts connection automatically, does not disconnect automatically
  -- in other words, you never need to tap "Receive" unless you've tapped
  "Disconnect".  Slurpee starts waiting immediately; after receiving each
  file, it beeps and waits for the next.
- adds support for "class:string" type for entrySpec so you can embed
  'class' information for strings directly with the value. For a phone
  entry, you could specify "homePhone:555 1234" for input, and you would
  get this format if you DUMP!
- source available in Slurpee format (slurpee.nwt) to registered Newt users

  (Input)
- ignores empty data entries, e.g., blank lines in non-Notes files
- checks that Notes labels is a symbol (or NIL) (avoids mutant soup entries)
- adds viewFont:, height: to entryspec for Notes [see below]
- calculates height of each Note as default
- broadcasts soup changes just once at end of transfer (rather than after each
  entry) -- more practical to use from within Newt to upload source code
- skips "sortOn fix" for non-Names data

  (Output--Dump)
- dumps multiple paragraphs within a Note as a single entry (without graphics)
- fixes bug of NIL array/frame subfields
- pauses optionally (previously, DUMP paused for 10 seconds). To pause to set
  up a log/capture file, include the number of seconds followed by a semi-colon,
  e.g., DUMP!10;


1.0 (6/6/94)
- initial public release
- added 10 second delay after a DUMP! to allow time to log/receive/capture a file
- added an ERASE! command to clear out all soup entries or just those in a folder
- added a "para" datatype (useful for adding a note to a Names card)
- disconnects more cleanly

0.1
- alpha/beta releases to Newt users

"0.0"
- Slurp example distributed by Apple DTS


==========
Author

Stephen Weyer
17 Timber Knoll Drive
Washington Crossing, PA 18977-1052
Internet: weyer@guest.apple.com
America Online/eWorld/NewtonMail: SteveWeyer
Compuserve: 74603,2051
AppleLink: WEYER.S


==========
Info about Newt

Newt 2.4:
a native development environment for simple applications using NewtonScript,
and for creating graphics using gestures, buttons, and NS.

Keywords: object-oriented programming, application development environment,
NewtonScript, NTK, learning, graphics, mathematics, Logo.

Where to usually find Newt [newt-devenv-24.sit/.zip/.hqx]:
- internet (also see mirror sites):
  - newton.uiowa.edu:pub/newton/software/app/ or /dev
  - sumex-aim.stanford.edu:info-mac/nwt/app/
  - ftp.amug.org:pub/newton
- newsgroups: comp.binaries.newton
- America Online(AOL): PDA:New Files (or PDA:Software Libraries:Newton)
- Compuserve: GO NEWTON (DL 8 or 9)
- AppleLink: Newton:Newton User Discussions:Freeware, Shareware and Demos
- eWorld: Shareware:Newton
  
Newt is shareware ($35) -- registered users receive a manual describing Newt
features and NewtonScript syntax, along with a floppy of other packages and
several dozen source examples -- of particular interest may be the Slurpee
application source itself in Slurpee format for Newt, and many example files
for program source, bitmaps and sounds.
